#include "VentanaPrincipal.h"
#include "ModelEstatico.h"
#include "ModelDinamico.h"
#include "ModelUsuarioclave.h"
#include "ModelError.h"
#include <sstream>
#include <iostream>
#include <fstream>
#include <list>

void VentanaPrincipal::on_click_CambiarVistaSolapas() {
	solapasVisibles = !solapasVisibles;
	ntbOpciones->set_show_tabs(solapasVisibles);
}

void VentanaPrincipal::on_click_btnAgregarUsuario() {
	Gtk::Entry* txtNombre;
	Gtk::Entry* txtClave;

	// Muestro el dialogo y espero hasta que elija una opcion.
	int result = dialogUsuario->run();
	builder->get_widget("txtNombre", txtNombre);
	builder->get_widget("txtClave", txtClave);

	// Reviso el resultado.
	switch (result) {
	case (Gtk::RESPONSE_OK): {
		agregarUsuario(txtNombre->get_text(), txtClave->get_text());
		txtNombre->set_text("");
		txtClave->set_text("");
		dialogUsuario->hide();
		barraEstado->push("Se agrego el usuario");
		break;
	}
	case (Gtk::RESPONSE_CANCEL): {
		txtNombre->set_text("");
		txtClave->set_text("");
		dialogUsuario->hide();
		barraEstado->push("Cancelar");
		break;
	}
	default: {
		break;
	}
	}
}

void VentanaPrincipal::on_click_btnModifUsuario() {
	Gtk::TreeView* tvUsuario;
	Gtk::Entry* txtNombre;
	Gtk::Entry* txtClave;

	Gtk::TreeModel::iterator iter;
	Glib::ustring nombre;
	Glib::ustring clave;
	Glib::RefPtr < Gtk::ListStore > listUsuario;
	Glib::RefPtr < Gtk::TreeView::Selection > refSelection;
	ModelUsuarioClave modelUsuario;

	builder->get_widget("tvUsuario", tvUsuario);
	builder->get_widget("txtNombre", txtNombre);
	builder->get_widget("txtClave", txtClave);

	listUsuario = Glib::RefPtr<Gtk::ListStore>::cast_static(
			builder->get_object("liststore1"));

	refSelection = tvUsuario->get_selection();

	if (refSelection) {
		iter = refSelection->get_selected();
		if (iter) {
			nombre = ((*iter)[modelUsuario.Usuario]);
			clave = ((*iter)[modelUsuario.Clave]);

			txtNombre->set_text(nombre);
			txtClave->set_text(clave);

			// Muestro el dialogo y espero hasta que elija una opcion.
			int result = dialogUsuario->run();

			// Reviso el resultado.
			switch (result) {
			case (Gtk::RESPONSE_OK): {
				barraEstado->push("Aceptar");
				((*iter)[modelUsuario.Usuario]) = txtNombre->get_text();
				((*iter)[modelUsuario.Clave]) = txtClave->get_text();
				txtNombre->set_text("");
				txtClave->set_text("");
				txtNombre->set_text("");
				txtClave->set_text("");
				dialogUsuario->hide();
				barraEstado->push("Se modifico correctamente el usuario");
				break;
			}
			case (Gtk::RESPONSE_CANCEL): {
				txtNombre->set_text("");
				txtClave->set_text("");
				dialogUsuario->hide();
				barraEstado->push("Cancelar");
				break;
			}
			default: {
				//barraEstado->push("que??");
				break;
			}
			}
		}
	}
	//barraEstado->push("Seleccionar una fila para modificar");
}

void VentanaPrincipal::on_click_btnEliminarUsuario() {
	Gtk::TreeView* tvUsuario;
	Glib::ustring nombre;
	Glib::RefPtr < Gtk::TreeView::Selection > refSelection;
	Glib::RefPtr < Gtk::ListStore > listUsuario;
	Gtk::TreeModel::iterator iter;
	ModelUsuarioClave modelUsuario;

	builder->get_widget("tvUsuario", tvUsuario);
	listUsuario = Glib::RefPtr<Gtk::ListStore>::cast_static(
			builder->get_object("liststore4"));

	refSelection = tvUsuario->get_selection();

	if (refSelection) {
		iter = refSelection->get_selected();
		if (iter) {
			nombre = ((*iter)[modelUsuario.Usuario]);
			listUsuario->erase(iter);
			barraEstado->push("Se elimino: " + nombre);
		} else
			barraEstado->push("Seleccionar una fila para eliminar");
	}
}

void VentanaPrincipal::on_click_btnAgregarError() {
	Gtk::Entry* txtNroError;
	Gtk::Entry* txtPathError;

	// Muestro el dialogo y espero hasta que elija una opcion.
	int result = dialogError->run();
	builder->get_widget("txtNroError", txtNroError);
	builder->get_widget("txtPathError", txtPathError);

	// Reviso el resultado.
	switch (result) {
	case (Gtk::RESPONSE_OK): {
		agregarError(txtNroError->get_text(), txtPathError->get_text());
		txtNroError->set_text("");
		txtPathError->set_text("");
		dialogError->hide();
		barraEstado->push("Se agrego el error");
		break;
	}
	case (Gtk::RESPONSE_CANCEL): {
		txtNroError->set_text("");
		txtPathError->set_text("");
		dialogError->hide();
		//barraEstado->push("Cancelar");
		break;
	}
	default: {
		break;
	}
	}
}

void VentanaPrincipal::on_click_btnModifError() {
	Gtk::TreeView* tvError;
	Gtk::Entry* txtNroError;
	Gtk::Entry* txtPathError;

	Gtk::TreeModel::iterator iter;
	Glib::ustring nroError;
	Glib::ustring pathError;
	Glib::RefPtr < Gtk::ListStore > listError;
	Glib::RefPtr < Gtk::TreeView::Selection > refSelection;
	ModelError modelError;

	builder->get_widget("txtNroError", txtNroError);
	builder->get_widget("txtPathError", txtPathError);
	builder->get_widget("tvError", tvError);

	listError = Glib::RefPtr<Gtk::ListStore>::cast_static(
			builder->get_object("liststore3"));

	refSelection = tvError->get_selection();

	if (refSelection) {
		iter = refSelection->get_selected();
		if (iter) {
			nroError = ((*iter)[modelError.NroError]);
			pathError = ((*iter)[modelError.Path]);
			txtNroError->set_text(nroError);
			txtPathError->set_text(pathError);

			// Muestro el dialogo y espero hasta que elija una opcion.
			int result = dialogError->run();

			// Reviso el resultado.
			switch (result) {
			case (Gtk::RESPONSE_OK): {
				((*iter)[modelError.NroError]) = txtNroError->get_text();
				((*iter)[modelError.Path]) = txtPathError->get_text();
				txtNroError->set_text("");
				txtPathError->set_text("");
				dialogError->hide();
				barraEstado->push("Se modifico correctamente el tipo error");
				break;
			}
			case (Gtk::RESPONSE_CANCEL): {
				txtNroError->set_text("");
				txtPathError->set_text("");
				dialogError->hide();
				barraEstado->push("Cancelar");
				break;
			}
			default: {
				//barraEstado->push("que??");
				break;
			}
			}
		}
	}
	//barraEstado->push("Seleccionar una fila para modificar");
}

void VentanaPrincipal::on_click_btnEliminarError() {
	Gtk::TreeView* tvError;
	Glib::ustring nroError;
	Glib::RefPtr < Gtk::TreeView::Selection > refSelection;
	Glib::RefPtr < Gtk::ListStore > listError;
	Gtk::TreeModel::iterator iter;
	ModelError modelError;

	builder->get_widget("tvError", tvError);
	listError = Glib::RefPtr<Gtk::ListStore>::cast_static(
			builder->get_object("liststore3"));

	refSelection = tvError->get_selection();

	if (refSelection) {
		iter = refSelection->get_selected();
		if (iter) {
			nroError = ((*iter)[modelError.NroError]);
			listError->erase(iter);
			barraEstado->push("Se elimino: " + nroError);
		} else
			barraEstado->push("Seleccionar una fila para eliminar");
	}
}

void VentanaPrincipal::on_click_btnAgregarDinamico() {
	Gtk::Entry* txtExtension;
	Gtk::Entry* txtComando;

	// Muestro el dialogo y espero hasta que elija una opcion.
	int result = dialogDinamico->run();
	builder->get_widget("txtExtensionDi", txtExtension);
	builder->get_widget("txtComando", txtComando);

	// Reviso el resultado.
	switch (result) {
	case (Gtk::RESPONSE_OK): {
		agregarTipoDinamico(txtExtension->get_text(), txtComando->get_text());
		txtExtension->set_text("");
		txtComando->set_text("");
		dialogDinamico->hide();
		barraEstado->push("Se agrego el tipo dinamico");
		break;
	}
	case (Gtk::RESPONSE_CANCEL): {
		txtExtension->set_text("");
		txtComando->set_text("");
		dialogDinamico->hide();
		barraEstado->push("Cancelar");
		break;
	}
	default: {
		break;
	}
	}
}

void VentanaPrincipal::on_click_btnModifDinamico() {
	Gtk::TreeView* tvDinamico;
	Gtk::Entry* txtExtension;
	Gtk::Entry* txtComando;

	Gtk::TreeModel::iterator iter;
	Glib::ustring extension;
	Glib::ustring comando;
	Glib::RefPtr < Gtk::ListStore > listDinamico;
	Glib::RefPtr < Gtk::TreeView::Selection > refSelection;
	ModelDinamico modelDinamico;

	builder->get_widget("txtExtensionDi", txtExtension);
	builder->get_widget("txtComando", txtComando);
	builder->get_widget("tvDinamico", tvDinamico);

	listDinamico = Glib::RefPtr<Gtk::ListStore>::cast_static(
			builder->get_object("liststore2"));

	refSelection = tvDinamico->get_selection();

	if (refSelection) {
		iter = refSelection->get_selected();
		if (iter) {
			extension = ((*iter)[modelDinamico.Extension]);
			comando = ((*iter)[modelDinamico.Comando]);

			txtExtension->set_text(extension);
			txtComando->set_text(comando);

			// Muestro el dialogo y espero hasta que elija una opcion.
			int result = dialogDinamico->run();

			// Reviso el resultado.
			switch (result) {
			case (Gtk::RESPONSE_OK): {
				((*iter)[modelDinamico.Extension]) = txtExtension->get_text();
				((*iter)[modelDinamico.Comando]) = txtComando->get_text();
				txtExtension->set_text("");
				txtComando->set_text("");
				dialogDinamico->hide();
				barraEstado->push("Se modifico correctamente el tipo dinamico");
				break;
			}
			case (Gtk::RESPONSE_CANCEL): {
				txtExtension->set_text("");
				txtComando->set_text("");
				dialogDinamico->hide();
				barraEstado->push("Cancelar");
				break;
			}
			default: {
				//barraEstado->push("que??");
				break;
			}
			}
		}
	}
	//barraEstado->push("Seleccionar una fila para modificar");
}

void VentanaPrincipal::on_click_btnEliminarDinamico() {
	Gtk::TreeView* tvDinamico;
	Glib::ustring extension;
	Glib::RefPtr < Gtk::TreeView::Selection > refSelection;
	Glib::RefPtr < Gtk::ListStore > listDinamico;
	Gtk::TreeModel::iterator iter;
	ModelDinamico modelDinamico;

	builder->get_widget("tvDinamico", tvDinamico);
	listDinamico = Glib::RefPtr<Gtk::ListStore>::cast_static(
			builder->get_object("liststore2"));

	refSelection = tvDinamico->get_selection();

	if (refSelection) {
		iter = refSelection->get_selected();
		if (iter) {
			extension = ((*iter)[modelDinamico.Extension]);
			listDinamico->erase(iter);
			barraEstado->push("Se elimino: " + extension);
		} else
			barraEstado->push("Seleccionar una fila para eliminar");
	}

}

void VentanaPrincipal::on_click_btnAgregarEstatico() {
	Gtk::Entry* txtExtension;
	Gtk::Entry* txtContenido;

	// Muestro el dialogo y espero hasta que elija una opcion.
	int result = dialogEstatico->run();
	builder->get_widget("txtExtensionEs", txtExtension);
	builder->get_widget("txtContenido", txtContenido);

	// Reviso el resultado.
	switch (result) {
	case (Gtk::RESPONSE_OK): {
		agregarTipoEstatico(txtExtension->get_text(), txtContenido->get_text());
		txtExtension->set_text("");
		txtContenido->set_text("");
		dialogEstatico->hide();
		barraEstado->push("Se agrego el tipo estatico");
		break;
	}
	case (Gtk::RESPONSE_CANCEL): {
		txtExtension->set_text("");
		txtContenido->set_text("");
		dialogEstatico->hide();
		barraEstado->push("Cancelar");
		break;
	}
	default: {
		break;
	}
	}
}

void VentanaPrincipal::on_click_btnModifEstatico() {
	Gtk::TreeView* tvEstatico;
	Gtk::Entry* txtExtension;
	Gtk::Entry* txtContenido;
	Gtk::TreeModel::iterator iter;
	Glib::ustring extension;
	Glib::ustring contenido;
	Glib::RefPtr < Gtk::ListStore > listEstatico;
	Glib::RefPtr < Gtk::TreeView::Selection > refSelection;
	ModelEstatico modelEstatico;

	builder->get_widget("tvEstatico", tvEstatico);
	builder->get_widget("txtExtensionEs", txtExtension);
	builder->get_widget("txtContenido", txtContenido);

	listEstatico = Glib::RefPtr<Gtk::ListStore>::cast_static(
			builder->get_object("liststore1"));

	refSelection = tvEstatico->get_selection();

	if (refSelection) {
		iter = refSelection->get_selected();
		if (iter) {
			extension = ((*iter)[modelEstatico.Extension]);
			contenido = ((*iter)[modelEstatico.Contenido]);

			txtExtension->set_text(extension);
			txtContenido->set_text(contenido);

			// Muestro el dialogo y espero hasta que elija una opcion.
			int result = dialogEstatico->run();

			// Reviso el resultado.
			switch (result) {
			case (Gtk::RESPONSE_OK): {
				barraEstado->push("Aceptar");
				((*iter)[modelEstatico.Extension]) = txtExtension->get_text();
				((*iter)[modelEstatico.Contenido]) = txtContenido->get_text();
				txtExtension->set_text("");
				txtContenido->set_text("");
				dialogEstatico->hide();
				barraEstado->push("Se modifico correctamente el tipo estatico");
				break;
			}
			case (Gtk::RESPONSE_CANCEL): {
				txtExtension->set_text("");
				txtContenido->set_text("");
				dialogEstatico->hide();
				barraEstado->push("Cancelar");
				break;
			}
			default: {
				//barraEstado->push("que??");
				break;
			}
			}
		}
	}
	//barraEstado->push("Seleccionar una fila para modificar");
}

void VentanaPrincipal::on_click_btnEliminarEstatico() {
	Gtk::TreeView* tvEstatico;
	Glib::ustring extension;
	Glib::RefPtr < Gtk::TreeView::Selection > refSelection;
	Glib::RefPtr < Gtk::ListStore > listEstatico;
	Gtk::TreeModel::iterator iter;
	ModelEstatico modelEstatico;

	builder->get_widget("tvEstatico", tvEstatico);
	listEstatico = Glib::RefPtr<Gtk::ListStore>::cast_static(
			builder->get_object("liststore1"));

	refSelection = tvEstatico->get_selection();

	if (refSelection) {
		iter = refSelection->get_selected();
		if (iter) {
			extension = ((*iter)[modelEstatico.Extension]);
			listEstatico->erase(iter);
			barraEstado->push("Se elimino: " + extension);
		} else
			barraEstado->push("Seleccionar una fila para eliminar");
	}
}

void VentanaPrincipal::on_click_btnExaminar() {
	Gtk::Entry* txtPathError;
	Gtk::FileChooserDialog dialog("Seleccionar archivo",
			Gtk::FILE_CHOOSER_ACTION_OPEN);
	builder->get_widget("txtPathError", txtPathError);
	dialog.set_transient_for(*ventanaPpal);

	// Agrego los botones para la respuesta:
	dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
	dialog.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_OK);
	// Muestro el dialogo y espero hasta que elija una opcion.
	int result = dialog.run();
	// Reviso el resultado.
	switch (result) {
	case (Gtk::RESPONSE_OK): {
		std::string filename = dialog.get_filename();
		txtPathError->set_text(filename);
		break;
	}
	case (Gtk::RESPONSE_CANCEL): {
		barraEstado->push("Carga de configuracion cancelada");
		break;
	}
	default: {
		break;
	}
	}
}

/**/
void VentanaPrincipal::on_click_btnExaminarLogAccesos() {
	Gtk::Entry* txtPathLogAccesos;
	Gtk::FileChooserDialog dialog("Seleccionar archivo",
			Gtk::FILE_CHOOSER_ACTION_OPEN);
	builder->get_widget("txtPathLogAccesos", txtPathLogAccesos);
	dialog.set_transient_for(*ventanaPpal);

	// Agrego los botones para la respuesta:
	dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
	dialog.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_OK);
	// Muestro el dialogo y espero hasta que elija una opcion.
	int result = dialog.run();
	// Reviso el resultado.
	switch (result) {
	case (Gtk::RESPONSE_OK): {
		std::string filename = dialog.get_filename();
		txtPathLogAccesos->set_text(filename);
		break;
	}
	case (Gtk::RESPONSE_CANCEL): {
		barraEstado->push("Carga de configuracion cancelada");
		break;
	}
	default: {
		break;
	}
	}
}

void VentanaPrincipal::on_click_btnExaminarLogErrores() {
	Gtk::Entry* txtPathLogError;
	Gtk::FileChooserDialog dialog("Seleccionar archivo",
			Gtk::FILE_CHOOSER_ACTION_OPEN);
	builder->get_widget("txtPathLogError", txtPathLogError);
	dialog.set_transient_for(*ventanaPpal);

	// Agrego los botones para la respuesta:
	dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
	dialog.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_OK);
	// Muestro el dialogo y espero hasta que elija una opcion.
	int result = dialog.run();
	// Reviso el resultado.
	switch (result) {
	case (Gtk::RESPONSE_OK): {
		std::string filename = dialog.get_filename();
		txtPathLogError->set_text(filename);
		break;
	}
	case (Gtk::RESPONSE_CANCEL): {
		barraEstado->push("Carga de configuracion cancelada");
		break;
	}
	default: {
		break;
	}
	}
}

/**/
void VentanaPrincipal::on_click_btnExaminarRaiz() {
	Gtk::Entry* txtRaiz;
	Gtk::FileChooserDialog dialog("Seleccionar archivo",
			Gtk::FILE_CHOOSER_ACTION_SELECT_FOLDER);
	builder->get_widget("txtRaiz", txtRaiz);
	dialog.set_transient_for(*ventanaPpal);

	// Agrego los botones para la respuesta:
	dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
	dialog.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_OK);

	// Muestro el dialogo y espero hasta que elija una opcion.
	int result = dialog.run();

	// Reviso el resultado.
	switch (result) {
	case (Gtk::RESPONSE_OK): {
		std::string filename = dialog.get_filename();
		txtRaiz->set_text(filename);
		break;
	}
	case (Gtk::RESPONSE_CANCEL): {
		break;
	}
	default: {
		break;
	}
	}
}

void VentanaPrincipal::conectarEventos() {
	Gtk::Button *btnTickSolapas;

	Gtk::Button *btnAgregarUsuario;
	Gtk::Button *btnEliminarUsuario;
	Gtk::Button *btnModifUsuario;

	Gtk::Button *btnAgregarError;
	Gtk::Button *btnEliminarError;
	Gtk::Button *btnModifError;

	Gtk::Button *btnAgregarEstatico;
	Gtk::Button *btnEliminarEstatico;
	Gtk::Button *btnModifEstatico;

	Gtk::Button *btnAgregarDinamico;
	Gtk::Button *btnEliminarDinamico;
	Gtk::Button *btnModifDinamico;

	Gtk::Button *btnExaminar;
	Gtk::Button *btnExaminarRaiz;

	Gtk::Button *btnExaminarLogAccesos;
	Gtk::Button *btnExaminarLogErrores;

	builder->get_widget("btnTickSolapas", btnTickSolapas);

	builder->get_widget("btnAgregarUsuario", btnAgregarUsuario);
	builder->get_widget("btnEliminarUsuario", btnEliminarUsuario);
	builder->get_widget("btnModifUsuario", btnModifUsuario);

	builder->get_widget("btnAgregarError", btnAgregarError);
	builder->get_widget("btnEliminarError", btnEliminarError);
	builder->get_widget("btnModifErro", btnModifError);

	builder->get_widget("btnAgregarEstatico", btnAgregarEstatico);
	builder->get_widget("btnEliminarEstatico", btnEliminarEstatico);
	builder->get_widget("btnModifEstatico", btnModifEstatico);

	builder->get_widget("btnAgregarDinamico", btnAgregarDinamico);
	builder->get_widget("btnEliminarDinamico", btnEliminarDinamico);
	builder->get_widget("btnModifDinamico", btnModifDinamico);

	builder->get_widget("btnExaminar", btnExaminar);
	builder->get_widget("btnExaminarRaiz", btnExaminarRaiz);

	builder->get_widget("btnExaminarLogAccesos", btnExaminarLogAccesos);
	builder->get_widget("btnExaminarLogErrores", btnExaminarLogErrores);

	btnTickSolapas->signal_clicked().connect(
			sigc::mem_fun(*this,
					&VentanaPrincipal::on_click_CambiarVistaSolapas));

	btnAgregarUsuario->signal_clicked().connect(
			sigc::mem_fun(*this, &VentanaPrincipal::on_click_btnAgregarUsuario));
	btnModifUsuario->signal_clicked().connect(
			sigc::mem_fun(*this, &VentanaPrincipal::on_click_btnModifUsuario));
	btnEliminarUsuario->signal_clicked().connect(
			sigc::mem_fun(*this, &VentanaPrincipal::on_click_btnEliminarUsuario));

	btnAgregarError->signal_clicked().connect(
			sigc::mem_fun(*this, &VentanaPrincipal::on_click_btnAgregarError));
	btnModifError->signal_clicked().connect(
			sigc::mem_fun(*this, &VentanaPrincipal::on_click_btnModifError));
	btnEliminarError->signal_clicked().connect(
			sigc::mem_fun(*this, &VentanaPrincipal::on_click_btnEliminarError));

	btnAgregarDinamico->signal_clicked().connect(
			sigc::mem_fun(*this, &VentanaPrincipal::on_click_btnAgregarDinamico));
	btnModifDinamico->signal_clicked().connect(
			sigc::mem_fun(*this, &VentanaPrincipal::on_click_btnModifDinamico));
	btnEliminarDinamico->signal_clicked().connect(
			sigc::mem_fun(*this,
					&VentanaPrincipal::on_click_btnEliminarDinamico));

	btnAgregarEstatico->signal_clicked().connect(
			sigc::mem_fun(*this, &VentanaPrincipal::on_click_btnAgregarEstatico));
	btnModifEstatico->signal_clicked().connect(
			sigc::mem_fun(*this, &VentanaPrincipal::on_click_btnModifEstatico));
	btnEliminarEstatico->signal_clicked().connect(
			sigc::mem_fun(*this,
					&VentanaPrincipal::on_click_btnEliminarEstatico));

	btnExaminar->signal_clicked().connect(
			sigc::mem_fun(*this, &VentanaPrincipal::on_click_btnExaminar));

	btnExaminarRaiz->signal_clicked().connect(
			sigc::mem_fun(*this, &VentanaPrincipal::on_click_btnExaminarRaiz));

	btnExaminarLogAccesos->signal_clicked().connect(
			sigc::mem_fun(*this,
					&VentanaPrincipal::on_click_btnExaminarLogAccesos));

	btnExaminarLogErrores->signal_clicked().connect(
			sigc::mem_fun(*this,
					&VentanaPrincipal::on_click_btnExaminarLogErrores));

}

void VentanaPrincipal::agregarTipoEstatico(const std::string &extension,
		const std::string &contenido) {

	ModelEstatico modelEstatico;
	Glib::RefPtr < Gtk::ListStore > listTipoEstatico = Glib::RefPtr<
			Gtk::ListStore>::cast_static(builder->get_object("liststore1"));

	typedef Gtk::TreeModel::Children type_children; //minimise code length.
	Gtk::TreeModel::Row row = *(listTipoEstatico->append());
	row[modelEstatico.Extension] = extension;
	row[modelEstatico.Contenido] = contenido;
}

void VentanaPrincipal::agregarTipoDinamico(const std::string &extension,
		const std::string &comando) {

	ModelEstatico modelDinamico;
	Glib::RefPtr < Gtk::ListStore > listTipoDinamico = Glib::RefPtr<
			Gtk::ListStore>::cast_static(builder->get_object("liststore2"));

	typedef Gtk::TreeModel::Children type_children; //minimise code length.
	Gtk::TreeModel::Row row = *(listTipoDinamico->append());
	row[modelDinamico.Extension] = extension;
	row[modelDinamico.Contenido] = comando;
}

void VentanaPrincipal::agregarUsuario(const std::string &nombre,
		const std::string &clave) {

	ModelUsuarioClave modelUsuario;
	Glib::RefPtr < Gtk::ListStore > listUsuario
			= Glib::RefPtr<Gtk::ListStore>::cast_static(
					builder->get_object("liststore4"));

	typedef Gtk::TreeModel::Children type_children; //minimise code length.
	Gtk::TreeModel::Row row = *(listUsuario->append());
	row[modelUsuario.Usuario] = nombre;
	row[modelUsuario.Clave] = clave;
}

void VentanaPrincipal::agregarError(const std::string &nroError,
		const std::string &path) {

	ModelError modelError;
	Glib::RefPtr < Gtk::ListStore > listError
			= Glib::RefPtr<Gtk::ListStore>::cast_static(
					builder->get_object("liststore3"));

	typedef Gtk::TreeModel::Children type_children; //minimise code length.
	Gtk::TreeModel::Row row = *(listError->append());
	row[modelError.NroError] = nroError;
	row[modelError.Path] = path;
}

void VentanaPrincipal::setConfiguracionBasica(
		const ConfiguracionBasica& confBasica) {
	std::stringstream auxStream;
	Gtk::SpinButton* sbtPuerto;
	Gtk::SpinButton* sbtPuertoContro;
	Gtk::SpinButton* sbtMaxConexiones;
	Gtk::SpinButton* sbtMaxConCliente;
	Gtk::SpinButton* sbtTimeOut;
	Gtk::Entry* txtRaiz;
	Gtk::CheckButton* cbtProtegido;

	builder->get_widget("sbtPuerto", sbtPuerto);
	builder->get_widget("sbtPuertoContro", sbtPuertoContro);
	builder->get_widget("txtRaiz", txtRaiz);
	builder->get_widget("cbtProtegido", cbtProtegido);
	builder->get_widget("sbtMaxConexiones", sbtMaxConexiones);
	builder->get_widget("sbtMaxConCliente", sbtMaxConCliente);
	builder->get_widget("sbtTimeOut", sbtTimeOut);

	sbtPuerto->set_value(confBasica.getPuerto());
	sbtPuertoContro->set_value(confBasica.getPuertoControl());
	sbtMaxConexiones->set_value(confBasica.getMaximoConexiones());
	sbtMaxConCliente->set_value(confBasica.getMaximoConexionesCliente());
	sbtTimeOut->set_value(confBasica.getTimeOut());
	txtRaiz->set_text(confBasica.getRaiz());

	//	confBasica.setPuertoControl(sbtPuertoContro->get_value());
	//	confBasica.setMaximoConexiones(sbtMaxConexiones->get_value());
	//	confBasica.setMaximoConexionesCliente(sbtMaxConCliente->get_value());
	//	confBasica.setTimeOut(sbtTimeOut->get_value());
	//	confBasica.setRaiz(txtRaiz->get_text());

	cbtProtegido->set_active(confBasica.getProteccion());

}

void VentanaPrincipal::setConfiguracionEstatico(
		std::list<TipoEstatico> configuracion) {
	std::list<TipoEstatico>::iterator it = configuracion.begin();

	ModelEstatico modelEstatico;
	Glib::RefPtr < Gtk::ListStore > listTipoEstatico = Glib::RefPtr<
			Gtk::ListStore>::cast_static(builder->get_object("liststore1"));
	listTipoEstatico->clear();

	while (it != configuracion.end()) {
		agregarTipoEstatico(it->getExtension(), it->getContenido());
		it++;
	}
}

void VentanaPrincipal::setConfiguracionDinamico(
		std::list<TipoDinamico> configuracion) {
	std::list<TipoDinamico>::iterator it = configuracion.begin();

	ModelEstatico modelDinamico;
	Glib::RefPtr < Gtk::ListStore > listTipoDinamico = Glib::RefPtr<
			Gtk::ListStore>::cast_static(builder->get_object("liststore2"));
	listTipoDinamico->clear();

	while (it != configuracion.end()) {
		agregarTipoDinamico(it->getExtension(), it->getComando());
		it++;
	}
}

void VentanaPrincipal::setConfiguracionUsuario(std::list<Usuario> configuracion) {
	std::list<Usuario>::iterator it = configuracion.begin();

	ModelUsuarioClave modelUsuario;
	Glib::RefPtr < Gtk::ListStore > listUsuario
			= Glib::RefPtr<Gtk::ListStore>::cast_static(
					builder->get_object("liststore4"));

	listUsuario->clear();

	while (it != configuracion.end()) {
		agregarUsuario(it->getNombre(), it->getClave());
		it++;
	}
}
void VentanaPrincipal::setConfiguracionReportes(ConfiguracionLogs confLog) {
	Gtk::Entry* pathReporteError;
	Gtk::Entry* pathReporteAccesos;

	builder->get_widget("txtPathLogAccesos", pathReporteAccesos);
	builder->get_widget("txtPathLogError", pathReporteError);

	pathReporteAccesos->set_text(confLog.getRutaLogAccesos());
	pathReporteError->set_text(confLog.getRutaLogErrores());
}

void VentanaPrincipal::setConfiguracionErrores(
		std::list<TipoError> configuracion) {
	std::list<TipoError>::iterator it = configuracion.begin();

	ModelError modelError;
	Glib::RefPtr < Gtk::ListStore > listError
			= Glib::RefPtr<Gtk::ListStore>::cast_static(
					builder->get_object("liststore3"));
	listError->clear();

	while (it != configuracion.end()) {
		std::stringstream nroError;
		nroError << it->getNroError();
		agregarError(nroError.str(), it->getRuta());
		it++;
		//nroError.clear();
	}

	//void VentanaPrincipal::agregarError(const std::string &nroError, const std::string &path) {

}

void VentanaPrincipal::cargarConfiguracion(const std::string &path) {
	Configuracion configuracion;
	configuracion.cargarDesde(path);

	setConfiguracionBasica(configuracion.getConfiguracionBasica());
	setConfiguracionEstatico(configuracion.getTiposEstaticos());
	setConfiguracionDinamico(configuracion.getTiposDinamicos());
	setConfiguracionUsuario(configuracion.getUsuarios());
	setConfiguracionErrores(configuracion.getTiposErrores());
	setConfiguracionReportes(configuracion.getConfiguracionLogs());

	/*	void setConfiguracionEstatico(std::list<TipoEstatico>& configuracion);
	 void setConfiguracionDinamico(std::list<TipoDinamico>& configuracion);
	 void setConfiguracionUsuario(std::list<Usuario>& configuracion);
	 void setConfiguracionErrores(std::list<TipoError>& configuracion);
	 * */
}

void VentanaPrincipal::on_click_CargarConfiguracion() {
	Gtk::FileChooserDialog dialog("Abrir archivo",
			Gtk::FILE_CHOOSER_ACTION_OPEN);

	dialog.set_transient_for(*ventanaPpal);

	// Agrego los botones para la respuesta:
	dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
	dialog.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_OK);

	// Muestro el dialogo y espero hasta que elija una opcion.
	int result = dialog.run();

	// Reviso el resultado.
	switch (result) {
	case (Gtk::RESPONSE_OK): {
		std::string filename = dialog.get_filename();
		cargarConfiguracion(filename);
		//barraEstado->push("Se cargo: " + filename);
		break;
	}
	case (Gtk::RESPONSE_CANCEL): {
		barraEstado->push("Carga de configuracion cancelada");
		break;
	}
	default: {
		barraEstado->push("No se pudo realizar la operacion");
		break;
	}
	}
}

int stringToInt(const std::string& cadena) {
	int auxEntero;
	std::stringstream auxStream;

	auxStream.clear();
	auxStream << cadena;
	auxStream >> auxEntero;
	return auxEntero;
}

void VentanaPrincipal::agregarConfiguracionBasica(Configuracion& configuracion) {
	std::stringstream auxStream;
	Gtk::SpinButton* sbtPuerto;
	Gtk::SpinButton* sbtPuertoContro;
	Gtk::SpinButton* sbtMaxConexiones;
	Gtk::SpinButton* sbtMaxConCliente;
	Gtk::SpinButton* sbtTimeOut;
	Gtk::Entry* txtRaiz;
	Gtk::CheckButton* cbtProtegido;

	builder->get_widget("sbtPuerto", sbtPuerto);
	builder->get_widget("sbtPuertoContro", sbtPuertoContro);
	builder->get_widget("txtRaiz", txtRaiz);
	builder->get_widget("cbtProtegido", cbtProtegido);
	builder->get_widget("sbtMaxConexiones", sbtMaxConexiones);
	builder->get_widget("sbtMaxConCliente", sbtMaxConCliente);
	builder->get_widget("sbtTimeOut", sbtTimeOut);

	ConfiguracionBasica confBasica;
	confBasica.setPuerto(sbtPuerto->get_value());
	confBasica.setPuertoControl(sbtPuertoContro->get_value());
	confBasica.setMaximoConexiones(sbtMaxConexiones->get_value());
	confBasica.setMaximoConexionesCliente(sbtMaxConCliente->get_value());
	confBasica.setTimeOut(sbtTimeOut->get_value());
	confBasica.setRaiz(txtRaiz->get_text());

	if (cbtProtegido->get_active())
		confBasica.proteger();

	configuracion.setConfiguracionBasica(confBasica);
}

void VentanaPrincipal::agregarConfiguracionEstatico(
		Configuracion& configuracion) {
	TipoEstatico* confEstatico;
	Glib::ustring extension;
	Glib::ustring contenido;

	Glib::RefPtr < Gtk::ListStore > listTipoEstatico = Glib::RefPtr<
			Gtk::ListStore>::cast_static(builder->get_object("liststore1"));

	typedef Gtk::TreeModel::Children type_children; //minimise code length.
	ModelEstatico modelEstatico;

	type_children children = listTipoEstatico->children();
	for (type_children::iterator iter = children.begin(); iter
			!= children.end(); ++iter) {
		Gtk::TreeModel::Row row = *iter;
		extension = (*iter)[modelEstatico.Extension];
		contenido = (*iter)[modelEstatico.Contenido];
		confEstatico = new TipoEstatico();
		confEstatico->setExtension(extension);
		confEstatico->setContenido(contenido);
		configuracion.agregarTipoEstatico(confEstatico);
	}
}

void VentanaPrincipal::agregarConfiguracionDinamico(
		Configuracion& configuracion) {
	TipoDinamico* confDinamico;
	Glib::ustring extension;
	Glib::ustring comando;

	Glib::RefPtr < Gtk::ListStore > listTipoDinamico = Glib::RefPtr<
			Gtk::ListStore>::cast_static(builder->get_object("liststore2"));

	typedef Gtk::TreeModel::Children type_children; //minimise code length.
	ModelDinamico modelDinamico;

	type_children children = listTipoDinamico->children();
	for (type_children::iterator iter = children.begin(); iter
			!= children.end(); ++iter) {
		Gtk::TreeModel::Row row = *iter;
		extension = (*iter)[modelDinamico.Extension];
		comando = (*iter)[modelDinamico.Comando];
		confDinamico = new TipoDinamico();
		confDinamico->setExtension(extension);
		confDinamico->setComando(comando);
		configuracion.agregarTipoDinamico(confDinamico);
	}
}

void VentanaPrincipal::agregarConfiguracionUsuario(Configuracion& configuracion) {
	Usuario* confUsuario;
	Glib::ustring nombre;
	Glib::ustring clave;

	Glib::RefPtr < Gtk::ListStore > listUsuarios
			= Glib::RefPtr<Gtk::ListStore>::cast_static(
					builder->get_object("liststore4"));

	typedef Gtk::TreeModel::Children type_children; //minimise code length.
	ModelUsuarioClave modelUsuarioClave;

	type_children children = listUsuarios->children();
	for (type_children::iterator iter = children.begin(); iter
			!= children.end(); ++iter) {
		Gtk::TreeModel::Row row = *iter;
		nombre = (*iter)[modelUsuarioClave.Usuario];
		clave = (*iter)[modelUsuarioClave.Clave];
		confUsuario = new Usuario();
		confUsuario->setNombre(nombre);
		confUsuario->setClave(clave);
		configuracion.agregarUsuario(confUsuario);
	}
}

void VentanaPrincipal::agregarConfiguracionErrores(Configuracion& configuracion) {
	Glib::ustring nroError;
	Glib::ustring path;
	int nroErrorEntero;

	Glib::RefPtr < Gtk::ListStore > listUsuarios
			= Glib::RefPtr<Gtk::ListStore>::cast_static(
					builder->get_object("liststore3"));

	typedef Gtk::TreeModel::Children type_children; //minimise code length.
	ModelError modelError;

	type_children children = listUsuarios->children();
	for (type_children::iterator iter = children.begin(); iter
			!= children.end(); ++iter) {
		Gtk::TreeModel::Row row = *iter;
		nroError = (*iter)[modelError.NroError];
		path = (*iter)[modelError.Path];
		nroErrorEntero = stringToInt(nroError);
		//configuracion.agregarError(nroErrorEntero, path);
		TipoError* tipoError = new TipoError();
		tipoError->setNroError(nroErrorEntero);
		tipoError->setRuta(path);
		configuracion.agregarError(tipoError);
	}
}

void VentanaPrincipal::agregarConfiguracionReportes(
		Configuracion& configuracion) {
	Gtk::Entry* pathReporteError;
	Gtk::Entry* pathReporteAccesos;

	builder->get_widget("txtPathLogAccesos", pathReporteAccesos);
	builder->get_widget("txtPathLogError", pathReporteError);

	ConfiguracionLogs confLogs;
	confLogs.setRutaLogAccesos(pathReporteAccesos->get_text());
	confLogs.setRutaLogErrores(pathReporteError->get_text());
	configuracion.setConfiguracionLogs(confLogs);
}

void VentanaPrincipal::guardarConfiguracion(const std::string &filename) {
	Configuracion configuracion;

	agregarConfiguracionBasica(configuracion);
	agregarConfiguracionEstatico(configuracion);
	agregarConfiguracionDinamico(configuracion);
	agregarConfiguracionErrores(configuracion);
	agregarConfiguracionReportes(configuracion);
	agregarConfiguracionUsuario(configuracion);
	configuracion.guardarComo(filename);

	barraEstado->push("Se guardo: " + filename);
}

void VentanaPrincipal::on_click_GuardarConfiguracion() {

	Gtk::FileChooserDialog dialog("Guardar como...",
			Gtk::FILE_CHOOSER_ACTION_SAVE);

	dialog.set_transient_for(*ventanaPpal);
	//Agrego los botones para la respuesta:
	dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
	dialog.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_OK);
	dialog.set_current_name("Configuracion.xml");
	dialog.set_do_overwrite_confirmation(true);

	//Muestro el dialogo y espero hasta que elija una opcion.
	int result = dialog.run();

	//Reviso el resultado.
	switch (result) {
	case (Gtk::RESPONSE_OK): {
		std::string filename = dialog.get_filename();
		guardarConfiguracion(filename);
		break;
	}
	case (Gtk::RESPONSE_CANCEL): {
		barraEstado->push("Carga de configuracion cancelada");
		break;
	}
	default: {
		barraEstado->push("No se pudo realizar la operacion");
		break;
	}
	}
}

void VentanaPrincipal::on_click_Salir() {
	Gtk::Main::quit();
}

void VentanaPrincipal::on_click_ConfiguracionBasica() {
	ntbOpciones->set_current_page(0);
}

void VentanaPrincipal::on_click_ConfiguracionTiposEstaticos() {
	ntbOpciones->set_current_page(1);
}

void VentanaPrincipal::on_click_ConfiguracionTiposDinamicos() {
	ntbOpciones->set_current_page(2);
}

void VentanaPrincipal::on_click_ConfiguracionErrores() {
	ntbOpciones->set_current_page(3);
}

void VentanaPrincipal::on_click_ConfiguracionUsuarios() {
	ntbOpciones->set_current_page(4);
}

void VentanaPrincipal::on_click_VerReportesErrores() {
	std::ifstream archivoError;
	std::string ubicacion;
	Gtk::Entry* txtPathLogError;
	Gtk::TextView* txtReporteError;
	Glib::RefPtr < Gtk::TextBuffer > m_refTextBuffer;
	char buffer[1024];

	builder->get_widget("txtReporteError", txtReporteError);
	builder->get_widget("txtPathLogError", txtPathLogError);
	m_refTextBuffer = txtReporteError->get_buffer();
	m_refTextBuffer->set_text("");

	ubicacion = txtPathLogError->get_text();

	archivoError.open(ubicacion.c_str());

	if (!archivoError.good()) {
		m_refTextBuffer->insert_at_cursor("No se encuentra el archivo ...");
	} else {
		while (archivoError.good()) {
			archivoError.getline(buffer, 1024, '\n');
			m_refTextBuffer->insert_at_cursor(buffer);
			m_refTextBuffer->insert_at_cursor("\n");
		}
	}
	txtReporteError->set_buffer(m_refTextBuffer);
	ntbOpciones->set_current_page(6);
}

void VentanaPrincipal::on_click_VerReportesAccesos() {
	std::ifstream archivoError;
	std::string ubicacion;
	Gtk::Entry* txtPathLogAccesos;
	Gtk::TextView* txtReporteAccesos;
	Glib::RefPtr < Gtk::TextBuffer > m_refTextBuffer;
	char buffer[1024];

	builder->get_widget("txtReporteAccesos", txtReporteAccesos);
	builder->get_widget("txtPathLogAccesos", txtPathLogAccesos);
	m_refTextBuffer = txtReporteAccesos->get_buffer();
	m_refTextBuffer->set_text("");

	ubicacion = txtPathLogAccesos->get_text();

	archivoError.open(ubicacion.c_str());

	if (!archivoError.good()) {
		m_refTextBuffer->insert_at_cursor("No se encuentra el archivo ...");
	} else {
		while (archivoError.good()) {
			archivoError.getline(buffer, 1024, '\n');
			m_refTextBuffer->insert_at_cursor(buffer);
			m_refTextBuffer->insert_at_cursor("\n");
		}
	}
	txtReporteAccesos->set_buffer(m_refTextBuffer);
	ntbOpciones->set_current_page(7);
}

void VentanaPrincipal::on_click_ConfiguracionReportes() {
	ntbOpciones->set_current_page(5);
}

void VentanaPrincipal::on_click_VerAyuda() {
	ntbOpciones->set_current_page(8);
}

void VentanaPrincipal::on_click_VerAcercaDe() {
	Gtk::AboutDialog* about;
	builder->get_widget("ventanaAcercaDe", about);
	if (about) {
		about->run();
		about->hide();
	}
}

void VentanaPrincipal::on_click_IniciarServidor() {
	std::string filename = "configTemp.xml";
	std::string comando = PATH_SERVIDOR;
	std::stringstream ss;
	int resultado;
	//Creo un xml temporal para iniciar el servidor.
	//guardarConfiguracion(filename);

	comando.append(" ");
	comando.append(filename);
	comando.append("&");

	resultado = system(comando.c_str());
	ss << resultado;
	barraEstado->push("se, iniciando servidor!.: " + ss.str());
}

void VentanaPrincipal::on_click_ReiniciarServidor() {
	on_click_DetenerServidor();
	on_click_IniciarServidor();
}

void VentanaPrincipal::on_click_DetenerServidor() {
	bool detenido;
	int nroPuerto;
	Gtk::SpinButton* sbtPuertoContro;

	builder->get_widget("sbtPuertoContro", sbtPuertoContro);
	nroPuerto = sbtPuertoContro->get_value();
	detenido = clienteControl.detenerServidor("127.0.0.1", nroPuerto);

	if (detenido)
		barraEstado->push("El servidor se cerro con exito");
	else
		barraEstado->push("Error: No se pude cerrar el servidor");
}

void VentanaPrincipal::cargarBarraDeMenu() {
	Gtk::Box *vboxMenuBar;

	menuArchivo = Gtk::ActionGroup::create();
	menuConfiguracion = Gtk::ActionGroup::create();
	menuControl = Gtk::ActionGroup::create();
	menuReportes = Gtk::ActionGroup::create();
	menuAyuda = Gtk::ActionGroup::create();

	//FIXME: CAMBIAR LOS ICONOS DEL MENU!
	/* Menu -Archivo- */
	menuArchivo->add(Gtk::Action::create("ArchivoMenu", "Archivo"));

	menuArchivo->add(
			Gtk::Action::create("Abrir", Gtk::Stock::DELETE, "_Abrir",
					"Abrir archivo"),
			sigc::mem_fun(*this,
					&VentanaPrincipal::on_click_CargarConfiguracion));

	menuArchivo->add(
			Gtk::Action::create("Guardar", Gtk::Stock::DELETE, "_Guardar",
					"Guardar configuracion"),
			sigc::mem_fun(*this,
					&VentanaPrincipal::on_click_GuardarConfiguracion));

	menuArchivo->add(Gtk::Action::create("Salir", Gtk::Stock::QUIT),
			sigc::mem_fun(*this, &VentanaPrincipal::on_click_Salir));

	/* Menu -Configuración- */
	menuConfiguracion->add(Gtk::Action::create("ConfigMenu", "Configuración"));

	menuConfiguracion->add(
			Gtk::Action::create("Basica", Gtk::Stock::PREFERENCES, "_Basica",
					"Configuracion basica"),
			sigc::mem_fun(*this,
					&VentanaPrincipal::on_click_ConfiguracionBasica));

	menuConfiguracion->add(
			Gtk::Action::create("tiposEstaticos", Gtk::Stock::PREFERENCES,
					"_Estaticos", "Configuracion tipos estaticos"),
			sigc::mem_fun(*this,
					&VentanaPrincipal::on_click_ConfiguracionTiposEstaticos));

	menuConfiguracion->add(
			Gtk::Action::create("tiposDinamicos", Gtk::Stock::PREFERENCES,
					"_Dinamicos", "Configuracion tipos dinamicos"),
			sigc::mem_fun(*this,
					&VentanaPrincipal::on_click_ConfiguracionTiposDinamicos));

	menuConfiguracion->add(
			Gtk::Action::create("tiposErrores", Gtk::Stock::PREFERENCES,
					"_Errores", "Configuracion tipos errores"),
			sigc::mem_fun(*this,
					&VentanaPrincipal::on_click_ConfiguracionErrores));

	menuConfiguracion->add(
			Gtk::Action::create("Usuarios", Gtk::Stock::PREFERENCES,
					"_Usuarios", "Configuracion usuarios"),
			sigc::mem_fun(*this,
					&VentanaPrincipal::on_click_ConfiguracionUsuarios));

	/* Menu -Control- */
	menuControl->add(Gtk::Action::create("ControlMenu", "Control"));

	menuControl->add(
			Gtk::Action::create("IniciarServidor", Gtk::Stock::PREFERENCES,
					"_Iniciar", "Iniciar Servidor"),
			sigc::mem_fun(*this, &VentanaPrincipal::on_click_IniciarServidor));

	menuControl->add(
			Gtk::Action::create("DetenerServidor", Gtk::Stock::PREFERENCES,
					"_Detener", "Detener Servidor"),
			sigc::mem_fun(*this, &VentanaPrincipal::on_click_DetenerServidor));

	menuControl->add(
			Gtk::Action::create("ReiniciarServidor", Gtk::Stock::PREFERENCES,
					"_Reiniciar", "Reiniciar Servidor"),
			sigc::mem_fun(*this, &VentanaPrincipal::on_click_ReiniciarServidor));

	/* Menu -Reportes- */
	menuReportes->add(Gtk::Action::create("ReportesMenu", "Reportes"));

	menuReportes->add(
			Gtk::Action::create("reporteAccesos", Gtk::Stock::PREFERENCES,
					"_Ver Reportes Accesos", "Configuracion reportes accesos"),
			sigc::mem_fun(*this, &VentanaPrincipal::on_click_VerReportesAccesos));
	menuReportes->add(
			Gtk::Action::create("reporteErrores", Gtk::Stock::PREFERENCES,
					"_Ver Reportes Errores", "Configuracion reportes errores"),
			sigc::mem_fun(*this, &VentanaPrincipal::on_click_VerReportesErrores));

	menuReportes->add(
			Gtk::Action::create("configurarReportes", Gtk::Stock::PREFERENCES,
					"_Configurar Reportes", "Configuracion de reportes"),
			sigc::mem_fun(*this,
					&VentanaPrincipal::on_click_ConfiguracionReportes));

	/* Menu -Ayuda- */
	menuAyuda->add(Gtk::Action::create("HelpMenu", "Ayuda"));
	menuAyuda->add(
			Gtk::Action::create("HelpAbout", Gtk::Stock::ABOUT, "A_cerca De",
					"Acerca de ..."),
			sigc::mem_fun(*this, &VentanaPrincipal::on_click_VerAcercaDe));
	menuAyuda->add(
			Gtk::Action::create("HelpMan", Gtk::Stock::HELP, "_Manual",
					"Manual"),
			sigc::mem_fun(*this, &VentanaPrincipal::on_click_VerAyuda));

	menu_UIManager = Gtk::UIManager::create();
	menu_UIManager->insert_action_group(menuArchivo);
	menu_UIManager->insert_action_group(menuConfiguracion);
	menu_UIManager->insert_action_group(menuControl);
	menu_UIManager->insert_action_group(menuReportes);
	menu_UIManager->insert_action_group(menuAyuda);

	ventanaPpal->add_accel_group(menu_UIManager->get_accel_group());

	//layout
	Glib::ustring ui_info = "<ui>"
		"  <menubar name='MenuBar'>"
		"    <menu action='ArchivoMenu'>"
		"      <menuitem action='Abrir'/>"
		"      <menuitem action='Guardar'/>"
		"          <separator/>"
		"      <menuitem action='Salir'/>"
		"    </menu>"
		"    <menu action='ConfigMenu'>"
		"      <menuitem action='Basica'/>"
		"      <menuitem action='tiposEstaticos'/>"
		"      <menuitem action='tiposDinamicos'/>"
		"      <menuitem action='tiposErrores'/>"
		"      <menuitem action='Usuarios'/>"
		"    </menu>"
		"    <menu action='ControlMenu'>"
		"      <menuitem action='IniciarServidor'/>"
		"      <menuitem action='DetenerServidor'/>"
		"      <menuitem action='ReiniciarServidor'/>"
		"    </menu>"
		"    <menu action='ReportesMenu'>"
		"      <menuitem action='reporteAccesos'/>"
		"      <menuitem action='reporteErrores'/>"
		"          <separator/>"
		"      <menuitem action='configurarReportes'/>"
		"    </menu>"
		"    <menu action='HelpMenu'>"
		"      <menuitem action='HelpMan'/>"
		"      <menuitem action='HelpAbout'/>"
		"    </menu>"
		"  </menubar>"
		"</ui>";

#ifdef GLIBMM_EXCEPTIONS_ENABLED
	try
	{
		menu_UIManager->add_ui_from_string(ui_info);
	}
	catch(const Glib::Error& ex)
	{
		std::cerr << "building menus failed: " << ex.what();
	}

#else
	std::auto_ptr < Glib::Error > ex;
	menu_UIManager->add_ui_from_string(ui_info, ex);
	if (ex.get()) {
		std::cerr << "building menus failed: " << ex->what();
	}
#endif //GLIBMM_EXCEPTIONS_ENABLED
	menu = menu_UIManager->get_widget("/MenuBar");

	builder->get_widget("vboxMenuBar", vboxMenuBar);
	vboxMenuBar->pack_end(*menu, Gtk::PACK_SHRINK);
}

void VentanaPrincipal::cargarBarraDeHerramientas() {
	/* Barra de herramientas */
	Gtk::ToolButton * toolbtAbrir;
	Gtk::ToolButton * toolbtGuardar;
	Gtk::ToolButton * toolbtIniciarServidor;
	Gtk::ToolButton * toolbtDetenerServidor;
	Gtk::ToolButton * toolbtReiniciarServidor;

	builder->get_widget("toolbtAbrir", toolbtAbrir);
	builder->get_widget("toolbtGuardar", toolbtGuardar);
	builder->get_widget("toolbtIniciarServidor", toolbtIniciarServidor);
	builder->get_widget("toolbtDetenerServidor", toolbtDetenerServidor);
	builder->get_widget("toolbtReiniciarServidor", toolbtReiniciarServidor);

	toolbtAbrir->signal_clicked().connect(
			sigc::mem_fun(*this,
					&VentanaPrincipal::on_click_CargarConfiguracion));

	toolbtGuardar->signal_clicked().connect(
			sigc::mem_fun(*this,
					&VentanaPrincipal::on_click_GuardarConfiguracion));

	toolbtIniciarServidor->signal_clicked().connect(
			sigc::mem_fun(*this, &VentanaPrincipal::on_click_IniciarServidor));

	toolbtDetenerServidor->signal_clicked().connect(
			sigc::mem_fun(*this, &VentanaPrincipal::on_click_DetenerServidor));

	toolbtReiniciarServidor->signal_clicked().connect(
			sigc::mem_fun(*this, &VentanaPrincipal::on_click_ReiniciarServidor));

}

void VentanaPrincipal::cargarWidget() {
	builder->get_widget("ntbOpciones", ntbOpciones);
	ntbOpciones->set_show_tabs(solapasVisibles);
	builder->get_widget("barraEstado", barraEstado);
}

void VentanaPrincipal::inicializarDialogos() {
	builder->get_widget("dialogEstatico", dialogEstatico);
	builder->get_widget("dialogDinamico", dialogDinamico);
	builder->get_widget("dialogError", dialogError);
	builder->get_widget("dialogUsuario", dialogUsuario);

	dialogEstatico->add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
	dialogEstatico->add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);

	dialogDinamico->add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
	dialogDinamico->add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);

	dialogError->add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
	dialogError->add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);

	dialogUsuario->add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
	dialogUsuario->add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);
}

void VentanaPrincipal::init(int argc, char *argv[]) {
	//	if (!Glib::thread_supported())
	//		Glib::thread_init();

	Gtk::Main kit(argc, argv);
	// Creo la GUI a partir del .glade

	// FIXME:Falta controlar si el archivo interface.glade no existe.
	// builder = Gtk::Builder::create_from_file("interface.glade");
	builder = Gtk::Builder::create_from_file("./Gui/Src/gui.glade");

	// Gtk::Window *ventanaPpal = 0;
	builder->get_widget("ventanaConfiguracion", ventanaPpal);

	conectarEventos();
	inicializarDialogos();
	cargarBarraDeMenu();
	cargarWidget();
	cargarBarraDeHerramientas();

	kit.run(*ventanaPpal);
}

VentanaPrincipal::VentanaPrincipal() {
	solapasVisibles = false;
}

VentanaPrincipal::~VentanaPrincipal() {
}
